#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <SDL/SDL_mixer.h>
#include "JeuSdl.h"
#include "VaisseauE.h"
#include "Terrain.h"
#include "TirJoueur.h"
#include "TirEnnemi.h"
#include "ListeTirJ.h"
#include "ListeTirE.h"
#include "Jeu.h"

# define NB_TIR 200
# define NB_TIR_E 50
# define NB_VAISS_E 50

const int TAILLE_SPRITE=32;
void sdljeuInit(sdlJeu *pSdlJeu)
{
	Jeu *pJeu;
	int dimx, dimy;

	pJeu = &(pSdlJeu->jeu);
	jeuInit(pJeu);
	TTF_Init();//pour pouvoir ecrire

	dimx = pJeu->jter.dimx;
	dimy = pJeu->jter.dimy;
	dimx = dimx/2 * TAILLE_SPRITE;
	dimy = dimy * TAILLE_SPRITE;
	pSdlJeu->surface_ecran = SDL_SetVideoMode(   dimx, dimy, 32, SDL_SWSURFACE );
	assert( pSdlJeu->surface_ecran!=NULL);
	SDL_WM_SetCaption( "Shoot Project", NULL );

/**********************chargement des images utilisées**********************/

	//on charge l'image du vaisseau joueur, elle doit exister
	pSdlJeu->surface_vaisseauJ = SDL_load_image("vaisseau.bmp");
	SDL_SetColorKey(pSdlJeu->surface_vaisseauJ, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_vaisseauJ->format, 0, 255, 0));//pour la transparence du vert
	assert( pSdlJeu->surface_vaisseauJ!=NULL);
	//on charge l'image du vaisseau ennemi, elle doit exister
	pSdlJeu->surface_vaisseauE = SDL_load_image("vaisseauE.bmp");
	SDL_SetColorKey(pSdlJeu->surface_vaisseauE, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_vaisseauE->format, 0, 0, 255));//pour la transparence du bleu
	assert( pSdlJeu->surface_vaisseauE!=NULL);
	//on charge l'image du vaisseau ennemi 2, elle doit exister
	pSdlJeu->surface_vaisseauE2 = SDL_load_image("Ennemi.bmp");
	SDL_SetColorKey(pSdlJeu->surface_vaisseauE2, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_vaisseauE2->format, 0, 255, 0));//pour la transparence du bleu
	assert( pSdlJeu->surface_vaisseauE2!=NULL);
	//on charge l'image du vaisseau ennemi 3, elle doit exister
	pSdlJeu->surface_vaisseauE3 = SDL_load_image("Ennemi2.bmp");
	SDL_SetColorKey(pSdlJeu->surface_vaisseauE3, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_vaisseauE3->format, 0, 0, 0));//pour la transparence du bleu
	assert( pSdlJeu->surface_vaisseauE3!=NULL);
	//on charge l'image du vaisseau ennemi 3, elle doit exister
	pSdlJeu->surface_vaisseauE4 = SDL_load_image("Ennemi3.bmp");
	SDL_SetColorKey(pSdlJeu->surface_vaisseauE3, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_vaisseauE4->format, 0, 0, 0));//pour la transparence du bleu
	assert( pSdlJeu->surface_vaisseauE4!=NULL);
    //on charge l'image du Boss 1, elle doit exister
	pSdlJeu->surface_boss1 = SDL_load_image("Boss1_1.bmp");
	SDL_SetColorKey(pSdlJeu->surface_boss1, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_boss1->format, 0, 0, 0));//pour la transparence du noir
	assert( pSdlJeu->surface_boss1!=NULL);
	//on charge l'image du Boss 2, elle doit exister
	pSdlJeu->surface_boss2 = SDL_load_image("Boss1_2.bmp");
	SDL_SetColorKey(pSdlJeu->surface_boss2, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_boss2->format, 0, 0, 0));//pour la transparence du noir
	assert( pSdlJeu->surface_boss2!=NULL);
	//on charge l'image du mur, elle doit exister
	pSdlJeu->surface_mur = SDL_load_image("mur2.bmp");
	assert( pSdlJeu->surface_mur!=NULL);
	//on charge l'image du tir joueur, elle doit exister
	pSdlJeu->surface_tirJ = SDL_load_image("tir1.bmp");
	SDL_SetColorKey(pSdlJeu->surface_tirJ, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_tirJ->format, 255, 0, 0));//pour la transparence du rouge
	assert( pSdlJeu->surface_tirJ!=NULL);
	//on charge l'image du tir joueur2, elle doit exister
	pSdlJeu->surface_tirJ2 = SDL_load_image("tirJ2.bmp");
	SDL_SetColorKey(pSdlJeu->surface_tirJ2, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_tirJ2->format, 0, 0, 0));//pour la transparence du rouge
	assert( pSdlJeu->surface_tirJ2!=NULL);
	//on charge l'image du tir ennemi, elle doit exister
	pSdlJeu->surface_tirE = SDL_load_image("tir2.bmp");
	SDL_SetColorKey(pSdlJeu->surface_tirE, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_tirE->format, 0, 0, 0));
	assert( pSdlJeu->surface_tirE!=NULL);
	//on charge l'image du tir ennemi2, elle doit exister
	pSdlJeu->surface_tirE2 = SDL_load_image("TirE2.bmp");
	SDL_SetColorKey(pSdlJeu->surface_tirE2, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_tirE2->format, 0, 0, 0));
	assert( pSdlJeu->surface_tirE2!=NULL);
    //on charge l'image du tir ennemi3, elle doit exister
	pSdlJeu->surface_tirE3 = SDL_load_image("tir3.bmp");
	SDL_SetColorKey(pSdlJeu->surface_tirE3, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_tirE->format, 0, 0, 0));
	assert( pSdlJeu->surface_tirE3!=NULL);
	//on charge l'image du bonus, elle doit exister
	pSdlJeu->surface_bonus_vie = SDL_load_image("Bonus_vie.bmp");
	SDL_SetColorKey(pSdlJeu->surface_bonus_vie, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_bonus_vie->format, 255, 0, 0));
	assert( pSdlJeu->surface_bonus_vie!=NULL);
    //on charge l'image du bonus, elle doit exister
	pSdlJeu->surface_bonus_arme = SDL_load_image("Bonus_arme.bmp");
	SDL_SetColorKey(pSdlJeu->surface_bonus_arme, SDL_SRCCOLORKEY, SDL_MapRGB(pSdlJeu->surface_bonus_arme->format, 255, 0, 0));
	assert( pSdlJeu->surface_bonus_arme!=NULL);

/**************************Chargement des sons********************************/

    pSdlJeu->son_Tir = Mix_LoadWAV("Tir.ogg");
    Mix_VolumeChunk(pSdlJeu->son_Tir, MIX_MAX_VOLUME/2);

    pSdlJeu->son_MortJ = Mix_LoadWAV("mortJ.ogg");
    Mix_VolumeChunk(pSdlJeu->son_MortJ, MIX_MAX_VOLUME/2);

    /**************************Chargement de la musique ********************************/

    Mix_VolumeMusic(MIX_MAX_VOLUME / 2); //Mettre le volume à la moitié
    pSdlJeu->musique_niveau1 = Mix_LoadMUS("Niveau1.mp3"); //Chargement de la musique
    pSdlJeu->musique_Boss1 = Mix_LoadMUS("Boss.mp3"); //Chargement de la musique
}

/**************************boucle de jeu********************************/

void sdljeuAff(sdlJeu *pSdlJeu, int k)
{
	TTF_Font *police = NULL;//pour gérer la police d'ecriture
	police = TTF_OpenFont("angelina.TTF", 60);//choix de la police
	SDL_Color couleurNoire = {0, 0, 0};
	SDL_Rect position;
	int x,y, i,temp = k, l, m;
	char vie[60] = "";
	CelluleTirJ *celluleTirJ;
    CelluleTirE *celluleTirE;
	CelluleVaissE *celluleVaissE;
	//on récupère les élements du jeu
	Terrain *pTer = &(pSdlJeu->jeu.jter);
	VaisseauJoueur *pVJ = &(pSdlJeu->jeu.jvaissJ);
	//on prend le tir et on ajoute plusieurs tirs a la chaine
	ListeTirJ *pTJ = jeuGetTirJ(&(pSdlJeu->jeu));
	if(pTJ->nbCellule<NB_TIR)
	nombreTirJ(pTJ, pVJ,NB_TIR);
	celluleTirJ = pTJ->adPremiere; // on prend la premiere cellule
	//on prend le vaisseauE et on ajoute plusieurs vaisseau a la chaine
	ListeVaissE *pVE =jeuGetVaissE(&(pSdlJeu->jeu));
	//if(pVE->nbCellule<NB_VAISS_E)
    //nombreVaissE(pVE, pTer, NB_VAISS_E);
    celluleVaissE = pVE->adPremiere;
	//on prend le tir et on ajoute plusieurs tirs a la chaine
	ListeTirE *pTE = jeuGetTirE(&(pSdlJeu->jeu));
	celluleTirE =pTE->adPremiere; // on prend la premiere cellule
	//on prend le score et la vie
	Score *pS = jeuGetScore(&(pSdlJeu->jeu));
	sprintf(vie, "Vie : %d, Score : %d", pSdlJeu->jeu.jvaissJ.vie, pS->scoreJ);
	pSdlJeu->surface_vie = TTF_RenderText_Blended(police, vie, couleurNoire);
	//on prend le bonus
	Bonus *pB = jeuGetBonus(&(pSdlJeu->jeu));

	//Remplir l'écran de noir
	SDL_FillRect( pSdlJeu->surface_ecran, &pSdlJeu->surface_ecran->clip_rect, SDL_MapRGB( pSdlJeu->surface_ecran->format, 0x00, 0x00, 0x00 ));

	//on place l'image des astéroides sur tous les '#' de l'ecran
	for (y=0; y<pTer->dimy; y++)
    {
        k=temp;
        for (x=0; x<pTer->dimx; x++)
            {
                if (terGetXY(pTer, k % pTer->dimx,y)=='#')
                    {
                        SDL_apply_surface(  pSdlJeu->surface_mur, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);
                    }
                k++;
            }
    }

	//Copier le sprite du vaisseau J sur l'ecran
	SDL_apply_surface(pSdlJeu->surface_vaisseauJ, pSdlJeu->surface_ecran, pVJ->x*TAILLE_SPRITE,  pVJ->y*TAILLE_SPRITE );
	//Copier le sprite du vaisseau E sur l'ecran
	for(l=0;l<pVE->nbCellule;l++)
    {
        if(celluleVaissE->vaiss->id == 'V')
        SDL_apply_surface(pSdlJeu->surface_vaisseauE, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );
        else if(celluleVaissE->vaiss->id == 'I')
        SDL_apply_surface(pSdlJeu->surface_vaisseauE2, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );
        else if(celluleVaissE->vaiss->id == 'N')
        SDL_apply_surface(pSdlJeu->surface_vaisseauE3, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );
        else if(celluleVaissE->vaiss->id == '#')
        SDL_apply_surface(pSdlJeu->surface_mur, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );
        else if(celluleVaissE->vaiss->id == 'A')
        SDL_apply_surface(pSdlJeu->surface_vaisseauE4, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );
        else if(celluleVaissE->vaiss->id == 'M')
        SDL_apply_surface(pSdlJeu->surface_boss1, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );
        else if(celluleVaissE->vaiss->id == 'K')
        SDL_apply_surface(pSdlJeu->surface_boss2, pSdlJeu->surface_ecran, celluleVaissE->vaiss->x*TAILLE_SPRITE,  celluleVaissE->vaiss->y*TAILLE_SPRITE );

        celluleVaissE = celluleVaissE->vaisSuiv;
    }
	//Copier le sprite du tir Joueur sur l'ecran
	for(i=0;i<pTJ->nbCellule;i++)
    {
        if(celluleTirJ->tir->typeTir == 1)
        SDL_apply_surface(pSdlJeu->surface_tirJ, pSdlJeu->surface_ecran, celluleTirJ->tir->x*TAILLE_SPRITE,  celluleTirJ->tir->y*TAILLE_SPRITE );
        if(celluleTirJ->tir->typeTir == 2)
        SDL_apply_surface(pSdlJeu->surface_tirJ2, pSdlJeu->surface_ecran, celluleTirJ->tir->x*TAILLE_SPRITE,  celluleTirJ->tir->y*TAILLE_SPRITE );
        celluleTirJ = celluleTirJ->tirsuiv;
    }
	//Copier le sprite du tir ennemi sur l'écran
	for(m=0;m<pTE->nbCellule;m++)
    {
        if(celluleTirE->tir->id == '+')
        SDL_apply_surface(pSdlJeu->surface_tirE, pSdlJeu->surface_ecran, celluleTirE->tir->x*TAILLE_SPRITE,  celluleTirE->tir->y*TAILLE_SPRITE );
        else if(celluleTirE->tir->id == '*')
        SDL_apply_surface(pSdlJeu->surface_tirE2, pSdlJeu->surface_ecran, celluleTirE->tir->x*TAILLE_SPRITE,  celluleTirE->tir->y*TAILLE_SPRITE );
        else if(celluleTirE->tir->id == '/')
        SDL_apply_surface(pSdlJeu->surface_tirE3, pSdlJeu->surface_ecran, celluleTirE->tir->x*TAILLE_SPRITE,  celluleTirE->tir->y*TAILLE_SPRITE );
        celluleTirE = celluleTirE->tirsuiv;
    }
    //Copier le sprite du bonus sur l'ecran
    if(pB->imBonus == 'V')
	SDL_apply_surface(pSdlJeu->surface_bonus_vie, pSdlJeu->surface_ecran, pB->x*TAILLE_SPRITE,  pB->y*TAILLE_SPRITE );
	else
	SDL_apply_surface(pSdlJeu->surface_bonus_arme, pSdlJeu->surface_ecran, pB->x*TAILLE_SPRITE,  pB->y*TAILLE_SPRITE );

	//on affiche la vie
	position.x = 60;
    position.y = 330;
	SDL_BlitSurface(pSdlJeu->surface_vie, NULL, pSdlJeu->surface_ecran, &position); /* Blit du texte par-dessus */
	TTF_CloseFont(police);
}

///*--------------------------------------------------*///
///* ------------------- Boucle --------------------- *///
///*--------------------------------------------------*///
void sdljeuBoucle(sdlJeu *pSdlJeu)
{
	niveau1(pSdlJeu);
}


void sdljeuDetruit( sdlJeu *pSdlJeu)
{
	SDL_FreeSurface( pSdlJeu->surface_vaisseauJ );
	SDL_FreeSurface( pSdlJeu->surface_mur );
	SDL_Quit();
	TTF_Quit();
}

void pause()
{
   int pause = 1;
   SDL_Event event;

    while(pause)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
            pause = 0;
            break;

            case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
                case SDLK_p:
                pause = 0;
                break;
                default:break;

            }
            break;


        }
    }
}

/// -------------------------------------------------------------- ///
/// ----------------- Fonctions pour le niveau 1 ----------------- ///
/// -------------------------------------------------------------- ///

/** déclenche un tir avec un temps d'intervalle
    ajoute le tir aux ennemis dont l'id est 'N'
    tempsEnnemi3 : pour l'intervalle entre les tirs**/
int declencheTir(sdlJeu *sdl, int tempsActuel, int tempsEnnemi3)
{
    int l;
    ListeVaissE *listevaiss2 = &(sdl->jeu.jvaissE);
    CelluleVaissE *VE2 = listevaiss2->adPremiere;
    if (tempsActuel - tempsEnnemi3 > 3000)
    {
        for(l=0;l<listevaiss2->nbCellule;l++)
        {
            if(VE2->vaiss->id == 'N')
                ajouteTirE2(jeuGetTirE(&(sdl->jeu)), VE2->vaiss);
            VE2 = VE2->vaisSuiv;
        }
        tempsEnnemi3 = tempsActuel;
    }
    return tempsEnnemi3;
}
/**Fais bouger les ennemis vers haut
    tempsEnnmi pour gerer la vitesse de l'ennemi : toute les 500ms **/
int bougerEnnemi(sdlJeu *sdl, int tempsActuel, int tempsEnnemi)
{
    int l;
    ListeVaissE *listevaiss2 = &(sdl->jeu.jvaissE);
    CelluleVaissE *VE2 = listevaiss2->adPremiere;
    if (tempsActuel - tempsEnnemi > 500)
    {
        for(l=0;l<listevaiss2->nbCellule;l++)//Pour le déplacement des vaisseaux
        {
            //Pour que l'ennemi monte
            if(VE2->vaiss->id == 'A')
                VE2->vaiss->y--;

            VE2 = VE2->vaisSuiv;
        }
        tempsEnnemi = tempsActuel;
    }
    return tempsEnnemi;
}

/** Fais bouger les ennemis de bas en haut,
    moveEnnemi2 permet de changer la direction du vaisseau : 1 pour descendre et -1 pour monter,
    tempsEnnemi2 pour gerer le temps de l'ennemi : Bouge toute les secondes **/
int bougerEnnemi2(sdlJeu *sdl, int tempsActuel, int tempsEnnemi2, int moveEnnemi2)
{
    int l;
    ListeVaissE *listevaiss2 = &(sdl->jeu.jvaissE);
    CelluleVaissE *VE2 = listevaiss2->adPremiere;
    if (tempsActuel - tempsEnnemi2 > 1000)
    {
        for(l=0;l<listevaiss2->nbCellule;l++)//Pour le déplacement des vaisseaux
        {
            //Pour que l'ennemi descend
            if(moveEnnemi2 == 1)
            {
                    if(VE2->vaiss->id == 'I' || VE2->vaiss->id == 'N')
                        VE2->vaiss->y++;
            }
            //Pour que l'ennemi monte
            if(moveEnnemi2 == -1)
            {
                    if(VE2->vaiss->id == 'I' || VE2->vaiss->id == 'N')
                        VE2->vaiss->y--;
            }
            VE2 = VE2->vaisSuiv;
        }
        tempsEnnemi2 = tempsActuel;
    }
    return tempsEnnemi2;
}

/** initialise les vaisseaux ennemis avec un timer et par rapport aux nombres de cellules dans la liste vaissE **/
void defileNiveau1(sdlJeu *pSdlJeu, int tempsActuel)
{
    int i;
    int j = 1;
    CelluleVaissE tempVE;
    Bonus *bonusV = jeuGetBonus(&pSdlJeu->jeu);
    if(tempsActuel > 1000 && pSdlJeu->jeu.jvaissE.nbCellule ==1)
    {
        ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
        tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
        ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
    }
    if(tempsActuel > 1200 && pSdlJeu->jeu.jvaissE.nbCellule ==2)
    {
        ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 4);
        tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
        ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
    }
    if(tempsActuel > 1300 && pSdlJeu->jeu.jvaissE.nbCellule ==3)
    {
        ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
        tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
        ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
    }
    if(tempsActuel > 2200 && pSdlJeu->jeu.jvaissE.nbCellule ==4)
    {
        ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
    }
    if(tempsActuel > 2300 && pSdlJeu->jeu.jvaissE.nbCellule ==5)
    {
        ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
    }
    if(tempsActuel > 2400 && pSdlJeu->jeu.jvaissE.nbCellule ==6)
    {
        ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
    }
    if(tempsActuel > 2500 && pSdlJeu->jeu.jvaissE.nbCellule ==7)
    {
        ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
    }
    if(tempsActuel > 2600 && pSdlJeu->jeu.jvaissE.nbCellule ==8)
    {
        ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 7);
    }
    if(tempsActuel > 2700 && pSdlJeu->jeu.jvaissE.nbCellule ==9)
    {
        ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 7);
    }
    if(tempsActuel > 5000 && pSdlJeu->jeu.jvaissE.nbCellule ==10)
    {
        ajouteVaissE3(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
        initBonus(bonusV, &(pSdlJeu->jeu.jter),1); // bonus pour l'arme
    }

    for(i=1;i<8;i++)
    {
        if(tempsActuel > 13000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+10)
        {
            ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), i+2);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }

    for(i=1;i<16;i+=2)
    {
        if(tempsActuel > 15000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+17)
        {
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }

    for(i=1;i<44;i+=7)
    {
        if(tempsActuel > 18000+j*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+33)
        {
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 4);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 8);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 9);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
        }
        j++;
    }
    for(i=1;i<44;i+=7)
    {
        if(tempsActuel > 18600+j*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+82)
        {
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 4);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 7);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
        }
        j++;
    }
    for(i=1;i<44;i+=7)
    {
        if(tempsActuel > 19200+j*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+131)
        {
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 7);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 8);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 9);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
        }
        j++;
    }
    for(i=1;i<8;i++)
    {
        if(tempsActuel > 23000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+180)
        {
            ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), i+2);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    if(tempsActuel > 24000 && pSdlJeu->jeu.jvaissE.nbCellule ==188)
    {
        ajouteVaissE3(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
        initBonus(bonusV, &(pSdlJeu->jeu.jter),2);//bonus de vie
    }

    for(i=1;i<6;i++)
    {
        if(tempsActuel > 25000+i*200 && pSdlJeu->jeu.jvaissE.nbCellule == i+188)
        {
            ajouteVaissE5(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 28+i);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    for(i=1;i<16;i+=2)
    {
        if(tempsActuel > 25000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+191)
        {
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
   for(i=1;i<3;i++)
    {
        if(tempsActuel > 28000+i*600 && pSdlJeu->jeu.jvaissE.nbCellule == i+207)
        {
            ajouteVaissE5(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 28);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    for(i=1;i<16;i+=2)
    {
        if(tempsActuel > 30000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+209)
        {
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    for(i=1;i<8;i++)
    {
        if(tempsActuel > 31000+i*200 && pSdlJeu->jeu.jvaissE.nbCellule == i+225)
        {
            ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), i+2);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    if(tempsActuel > 35000 && pSdlJeu->jeu.jvaissE.nbCellule == 233)
    {
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 4);
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 9);
        ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
    }
    for(i=1;i<3;i++)
    {
        if(tempsActuel > 36000+i*600 && pSdlJeu->jeu.jvaissE.nbCellule == i+239)
        {
            ajouteVaissE5(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 30);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE2(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    for(i=1;i<8;i++)
    {
        if(tempsActuel > 39000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+241)
        {
            ajouteVaissE(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), i+2);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    for(i=1;i<16;i+=2)
    {
        if(tempsActuel > 42000+i*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+248)
        {
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE2(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    for(i=1;i<15;i+=7)
    {
        if(tempsActuel > 45000+j*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+264)
        {
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 4);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 8);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 9);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
        }
        j++;
    }
    for(i=1;i<15;i+=7)
    {
        if(tempsActuel > 45500+j*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+278)
        {
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 7);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 8);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 9);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
        }
        j++;
    }
    for(i=1;i<15;i+=7)
    {
        if(tempsActuel > 46000+j*100 && pSdlJeu->jeu.jvaissE.nbCellule == i+292)
        {
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 2);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 3);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 4);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 5);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 6);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 9);
            ajouteVaissE4(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 10);
        }
        j++;
    }
    for(i=1;i<3;i++)
    {
        if(tempsActuel > 49500+i*600 && pSdlJeu->jeu.jvaissE.nbCellule == i+306)
        {
            ajouteVaissE5(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 20);
            if(i%2 == 0)
            {
                tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
                ajouteTirE2(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
            }
        }
    }
    if(tempsActuel > 60000 && pSdlJeu->jeu.jvaissE.nbCellule == 309)
    {
        ajouteBoss1(&(pSdlJeu->jeu.jvaissE),  &(pSdlJeu->jeu.jter), 0);
        tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));
        testamentTirE(&(pSdlJeu->jeu.jtirE));
        initListeTirE(&(pSdlJeu->jeu.jtirE), tempVE.vaiss);
        ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,0, 7);
        ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,1, 6);
        Mix_PlayMusic(pSdlJeu->musique_Boss1, -1);
    }

}

int tirBoss(sdlJeu *pSdlJeu, int tempsActuel, int tempsBoss)
{
    int i;
    CelluleVaissE tempVE;
    tempVE = finListe(jeuGetVaissE(&(pSdlJeu->jeu)));

    if(tempsActuel > 62000 && tempsActuel - tempsBoss > 1500)
        {
            if(tempVE.vaiss->vie%7 == 0)
            {
                for(i=1;i<5;i++)
                {
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 3);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 6);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 7);
                }
            }
            else if(tempVE.vaiss->vie%2 == 0)
            {
                for(i=1;i<7;i++)
                {
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 2);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 3);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 5);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 7);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 8);
                }
            }
            if(tempVE.vaiss->vie%2 == 1)
            {
                 for(i=1;i<7;i++)
                {
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 3);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 5);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 6);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 8);
                    ajouteTirE3(&(pSdlJeu->jeu.jtirE), tempVE.vaiss,i, 9);
                }
            }
            tempsBoss = tempsActuel;
        }
        return tempsBoss;
}

void niveau1(sdlJeu *pSdlJeu)
{
    int k=0,i,j=0, l; // k pour le defilement du terrain, i pour l'incrementation lors du défilement tu tir joueur, j pour savoir si on arrive a la fin de la liste du tir joueur
    int temp=0;//pour ralentir le vaisseauE, il va trop vite en sdl
    int joueMortJ; // pour joueur le son quand le joueur perd une vie
    int moveEnnemi2 = 1, mortJ = 0; // mortJ sert a etre invicible pendant quelque seconde apres la mort
    SDL_Event event;
    int typeTir=1; // definit le type de tir
    int tempsActuel = 0, tempsPrecedent = 0,tempsEnnemi = 0, tempsEnnemi2 = 0, tempsEnnemi3 = 0, intervalleEnnemi2 = 0, tempsInvincible=0, tempsBoss = 0, resetTemps = SDL_GetTicks(); //variable pour gerer le temps
    int continue_boucle = 1;//permet de faire boucler le jeu
    Mix_PlayMusic(pSdlJeu->musique_niveau1, -1); //Jouer infiniment la musique

    assert( SDL_Flip( pSdlJeu->surface_ecran )!=-1 );

    /* -- Pour le déclenchement du tir -- */
    ListeTirJ *listeTir1 = jeuGetTirJ(&pSdlJeu->jeu);
    CelluleTirJ *tir1 = listeTir1->adPremiere;

    /* -- Pour le déplacement du tir -- */
    ListeTirJ *listeTir2 = jeuGetTirJ(&pSdlJeu->jeu);
    CelluleTirJ *tir2;

    /* -- Pour le déplacement des vaisseauE -- */
    ListeVaissE * listevaiss2 = jeuGetVaissE(&pSdlJeu->jeu);
    CelluleVaissE *VE2 = listevaiss2->adPremiere;

    /* -- Pour le déplacement des tirsE -- */
    ListeTirE * listetirE = jeuGetTirE(&pSdlJeu->jeu);
    CelluleTirE *TE;

    /* -- Pour le déplacement du bonus -- */
    Bonus *bonusV = jeuGetBonus(&pSdlJeu->jeu);

    //pour activer la répétition des touches
    SDL_EnableKeyRepeat(20, 40);

    // tant que ce n'est pas la fin ...
    while ( continue_boucle == 1 )
    {
        //on prend le temps
        tempsActuel = SDL_GetTicks()-resetTemps;

        defileNiveau1(pSdlJeu, tempsActuel);

        //on affiche le jeu sur le buffer caché
        sdljeuAff(pSdlJeu,k);

        // on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans a boucle)
        SDL_Flip( pSdlJeu->surface_ecran );
        // remet tir2 au début de la liste a chaque fois qu'on passe dans la boucle
        tir2 = listeTir2->adPremiere;
        TE = listetirE->adPremiere;

        while ( SDL_PollEvent( &event ) )
        {
            // tant qu'il y a des evenements à traiter : cette boucle n'est pas bloquante
            // Si l'utilisateur a cliqué sur la croix de fermeture
            if ( event.type == SDL_QUIT )
                    continue_boucle = 0;

            // Si l'utilisateur a appuyé sur une touche
            if ( event.type == SDL_KEYDOWN )
            {
                    switch ( event.key.keysym.sym )
                    {
                    case SDLK_UP:
                            hautJoueur(&(pSdlJeu->jeu.jvaissJ), &(pSdlJeu->jeu.jter));
                            break;
                    case SDLK_DOWN:
                            basJoueur(&(pSdlJeu->jeu.jvaissJ), &(pSdlJeu->jeu.jter));
                            break;
                    case SDLK_LEFT:
                            gaucheJoueur(&(pSdlJeu->jeu.jvaissJ), &(pSdlJeu->jeu.jter));
                            break;
                    case SDLK_RIGHT:
                            droiteJoueurSdl(&(pSdlJeu->jeu.jvaissJ), &(pSdlJeu->jeu.jter));
                            //lancer++;
                            break;
                    case 32: // ESPACE
                            Mix_PlayChannel(3, pSdlJeu->son_Tir, 0);
                            initTir(tir1->tir, &(pSdlJeu->jeu.jvaissJ), typeTir);
                            tir1 = tir1->tirsuiv;
                            if(j == NB_TIR) //remet le tir au debut de la liste quand il arrive a la fin
                            {
                                tir1 =listeTir1->adPremiere;
                                j=0;
                            }
                            j++;
                            break;
                    case SDLK_p:
                            resetTemps = tempsActuel;
                            pause();
                            resetTemps = SDL_GetTicks()-resetTemps;
                            break;
                    case 27: //ECHAP
                            continue_boucle = 0;
                    break;
                    default: break;
                    }
            }

        }
        //vitesse du tir joueur
        if(temp!=10)
                temp++;
        else
        {
            //déplacement tous les tirs de la liste
            for(i=0;i<=NB_TIR;i++)
            {
                if (toucheBonus(jeuGetVaissJ(&pSdlJeu->jeu), jeuGetBonus(&pSdlJeu->jeu), tir2) == 2)
                {
                    typeTir = 2;
                    Mix_PlayChannel(3, pSdlJeu->son_Tir, 0);
                }
                else if (toucheBonus(jeuGetVaissJ(&pSdlJeu->jeu), jeuGetBonus(&pSdlJeu->jeu), tir2) == 1)
                {
                    Mix_PlayChannel(3, pSdlJeu->son_Tir, 0);
                }
                toucheEnnemi(tir2, &(pSdlJeu->jeu.jvaissE), &(pSdlJeu->jeu.jscoreJ));
                tir2->tir->x++;
                tir2 = tir2->tirsuiv;
            }
            temp = 0;
        }

    //pour stopper le jeu des que le nombre de vie egale 0
    if(pSdlJeu->jeu.jvaissJ.vie <= 0)
    {
        continue_boucle=0;
    }

    ///*--------------------------------------------------*///
    ///* ----------- Début déplacement ennemi ----------- *///
    ///*--------------------------------------------------*///

    /* On déplace les joueurs et les tirs ennemis en parcourant leurs boucles.
        On teste si le joueur est mort, si le joueur perd une vie il devient invincible pendant 3 secondes */

    if (tempsActuel - tempsPrecedent > 100)
    {
        if(tempsActuel < 55000)
        {
             k++;// defilement du terrain
        } // On arrete le défilement a 55 secondes

        //if(tempsActuel > 13000)
        bonusV->x--;// on fait avancer le bonus a partir de 16 secondes

        for(l=0;l<listevaiss2->nbCellule;l++)//On parcourt la liste des vaisseaux ennemis
        {
            if(mortJ==1)//on vérifie si le joueur vient de se faire tuer
            {
                if(joueMortJ) // on joue le son de la mort du joueur
                {
                    Mix_PlayChannel(4, pSdlJeu->son_MortJ, 0);
                    joueMortJ = 0; // pour jouer le son qu'une seule fois
                    typeTir = 1; // on enleve le bonus
                }
                if (tempsActuel - tempsInvincible > 3000) //Le joueur est invincible pendant 3 secondes
                {
                    mortJ = 0;
                    tempsInvincible = tempsActuel;
                }
            }
            else //sinon on test si le joueur est mort
            {
                mortJ = mortJoueur(&(pSdlJeu->jeu.jvaissJ), TE->tir,VE2->vaiss, &(pSdlJeu->jeu.jter), &(pSdlJeu->jeu.jscoreJ));
                joueMortJ = 1; // pour jouer le son quand le joueur se fait toucher
            }

            if(VE2->vaiss->id != 'N' && VE2->vaiss->id != 'M' && VE2->vaiss->id != 'K')//On fait avancer tous les vaisseaux sauf l'ennemi3 et le boss
            VE2->vaiss->x--;

            VE2 = VE2->vaisSuiv;
        }
        VE2 = listevaiss2->adPremiere;

        for(l=0;l < listetirE->nbCellule;l++)//On parcourt la liste des tirs ennemis
        {
            if(mortJ==1)//on vérifie si le joueur vient de se faire tuer
            {
                if(joueMortJ) // on joue le son de la mort du joueur
                {
                    Mix_PlayChannel(4, pSdlJeu->son_MortJ, 0);
                    joueMortJ = 0;
                    typeTir = 1;
                }
                if (tempsActuel - tempsInvincible > 3000) //Le joueur est invincible pendant 3 secondes
                {
                    mortJ = 0;
                    tempsInvincible = tempsActuel;
                }
            }
            else //sinon on test si le joueur est mort
            {
                mortJ = mortJoueur(&(pSdlJeu->jeu.jvaissJ), TE->tir,VE2->vaiss, &(pSdlJeu->jeu.jter), &(pSdlJeu->jeu.jscoreJ));
                joueMortJ = 1;
            }
            TE->tir->x-=2;
            TE = TE->tirsuiv;
        }
        tempsPrecedent = tempsActuel;
    }

    // permet de changer la direction de l'ennemi dans la fonction bougerEnnemi2
    if (tempsActuel - intervalleEnnemi2 > 3000)
    {
        moveEnnemi2 *= -1;
        intervalleEnnemi2 = tempsActuel;
    }
    tempsEnnemi3 = declencheTir(pSdlJeu, tempsActuel, tempsEnnemi3);
    tempsEnnemi2 = bougerEnnemi2(pSdlJeu, tempsActuel, tempsEnnemi2, moveEnnemi2);
    tempsEnnemi = bougerEnnemi(pSdlJeu, tempsActuel, tempsEnnemi);
    tempsBoss = tirBoss(pSdlJeu, tempsActuel, tempsBoss);

    //stopListeTir(jeuGetTirJ(&(pSdlJeu->jeu)), jeuGetTerrain(&(pSdlJeu->jeu)));
    }

    /** ----------- Liberation de la memoire ------------**/

    terLibere(&(pSdlJeu->jeu.jter));
    testamentTirJ(&(pSdlJeu->jeu.jtirJ));
    testamentVaissE(&(pSdlJeu->jeu.jvaissE));
    testamentTirE(&(pSdlJeu->jeu.jtirE));
    Mix_FreeChunk(pSdlJeu->son_Tir);//Libération du son 1
    Mix_FreeChunk(pSdlJeu->son_MortJ);
}

SDL_Surface *SDL_load_image(const char* filename )
{
	/* Temporary storage for the image that's loaded */
	SDL_Surface* loadedImage = NULL;

	/* The optimized image that will be used */
	SDL_Surface* optimizedImage = NULL;

	/* Load the image */
	loadedImage = SDL_LoadBMP( filename );

	/* If nothing went wrong in loading the image */
	if ( loadedImage != NULL )
	{
		/* Create an optimized image */
		optimizedImage = SDL_DisplayFormat( loadedImage );

		/* Free the old image */
		SDL_FreeSurface( loadedImage );
	}

	/* Return the optimized image */
	return optimizedImage;
}


void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y )
{
	/* Make a temporary rectangle to hold the offsets */
	SDL_Rect offset;

	/* Give the offsets to the rectangle */
	offset.x = x;
	offset.y = y;

	/* Blit the surface */
	SDL_BlitSurface( source, NULL, destination, &offset );
}

